
//`define sim

module DDS_AD9767(
	clk	,	// 系统时钟50mhz
	rst_n	,
	// 通道A
	data_A,
	clk_A	,
	WRTA	,
	// 通道B
	data_B,
	clk_B	,
	key		,
	WRTB	
	);
	input key;
	input 			clk	;
	input 			rst_n	;
	// 通道A
	output [13:0]	data_A;
	output 			clk_A	;
	output 			WRTA	;
	// 通道B
	output [13:0]	data_B;
	output 			clk_B	;
	output 			WRTB	;
	
	
	reg f1, f2;
	wire flag;


	
	
	
	
	
	
	// 时钟125Mhz
	wire 				clk_125M;
	assign clk_A = clk_125M;
	assign WRTA  = clk_125M;
	assign clk_B = clk_125M;
	assign WRTB  = clk_125M;
	
	PLL_125	PLL_125_inst (
		.inclk0 ( clk ),
		.c0 	  ( clk_125M )
	);
	
	reg  [1:0]		model_selA,model_selB;
	reg  [31:0]		FwordA,FwordB			;
	reg  [11:0]		PwordA,PwordB			;
	
	DDS_model DDS_modelA(			// 通道A输出
		.clk			(clk_125M	), 
		.rst_n		(rst_n		),
		.model_sel	(model_selA	),
		.Fword		(FwordA		),
		.Pword		(PwordA		),
		.data			(data_A		)
	);

	DDS_model DDS_modelB(			// 通道B输出
		.clk			(clk_125M	), 
		.rst_n		(rst_n		),
		.model_sel	(model_selB	),
		.Fword		(FwordB		),
		.Pword		(PwordB		),
		.data			(data_B		)
	);
	
	
		always @(posedge clk_125M ) begin
			f1 <= key;
			f2 <= f1; end
	assign flag = 	~f2 & f1;	
	

	
/******************虚拟按键输入*************/
	wire CH_model_selA, CH_model_selB;
	wire CH_FwordA, CH_FwordB;
	wire CH_PwordA, CH_PwordB;
	// 通道A 模式选择 虚拟按键输入
	ISSP	ISSP_model_selA (	
		.probe (  ),
		.source ( CH_model_selA )
	);
	// 通道A 频率控制字 选择虚拟按键输入
	ISSP	ISSP_FwordA (	
		.probe (  ),
		.source ( CH_FwordA )
	);
	// 通道A 相位控制字 虚拟按键输入
	ISSP	ISSP_PwordA (	
		.probe (  ),
		.source ( CH_PwordA )
	);
	
	// 通道B 模式选择 虚拟按键输入
	ISSP	ISSP_model_selB (	
		.probe (  ),
		.source ( CH_model_selB )
	);
	// 通道B 频率控制字 选择虚拟按键输入
	ISSP	ISSP_FwordB (	
		.probe (  ),
		.source ( CH_FwordB )
	);
	// 通道B 相位控制字 虚拟按键输入
	ISSP	ISSP_PwordB (	
		.probe (  ),
		.source ( CH_PwordB )
	);

/******************虚拟按键，检测上升沿*************/
	// 打俩拍
	reg CH_model_selA_reg0, CH_model_selA_reg1;
	reg CH_model_selB_reg0, CH_model_selB_reg1;
	reg CH_FwordA_reg0, CH_FwordA_reg1;
	reg CH_FwordB_reg0, CH_FwordB_reg1;
	reg CH_PwordA_reg0, CH_PwordA_reg1;
	reg CH_PwordB_reg0, CH_PwordB_reg1;
	
	always @(posedge clk_125M) begin
		CH_model_selA_reg0 <= CH_model_selA;
		CH_model_selA_reg1 <= CH_model_selA_reg0;
	end
	
	always @(posedge clk_125M) begin
		CH_model_selB_reg0 <= CH_model_selB;
		CH_model_selB_reg1 <= CH_model_selB_reg0;
	end
	
	always @(posedge clk_125M) begin
		CH_FwordA_reg0 <= CH_FwordA;
		CH_FwordA_reg1 <= CH_FwordA_reg0;
	end
	
	always @(posedge clk_125M) begin
		CH_FwordB_reg0 <= CH_FwordB;
		CH_FwordB_reg1 <= CH_FwordB_reg0;
	end
	
	always @(posedge clk_125M) begin
		CH_PwordA_reg0 <= CH_PwordA;
		CH_PwordA_reg1 <= CH_PwordA_reg0;
	end
	
	always @(posedge clk_125M) begin
		CH_PwordB_reg0 <= CH_PwordB;
		CH_PwordB_reg1 <= CH_PwordB_reg0;
	end
	
	// 上升沿检测
	wire CH_model_selA_pos, CH_model_selB_pos;
	wire CH_FwordA_pos, CH_FwordB_pos;
	wire CH_PwordA_pos, CH_PwordB_pos;
	
	assign CH_model_selA_pos = (!CH_model_selA_reg1) & CH_model_selA_reg0;
	assign CH_model_selB_pos = (!CH_model_selB_reg1) & CH_model_selB_reg0;
	assign CH_FwordA_pos 	 = (!CH_FwordA_reg1) & CH_FwordA_reg0;
	assign CH_FwordB_pos 	 = (!CH_FwordB_reg1) & CH_FwordB_reg0;
	assign CH_PwordA_pos 	 = (!CH_PwordA_reg1) & CH_PwordA_reg0;
	assign CH_PwordB_pos 	 = (!CH_PwordB_reg1) & CH_PwordB_reg0;
	
/****************** 波形，频率控制字,相位控制字选择 *************/	
	reg [2:0] CH_FwordA_sel, CH_FwordB_sel;
	reg [2:0] CH_PwordA_sel, CH_PwordB_sel;
	// 通道A  波形选择
	always@(posedge clk_125M or negedge rst_n) begin
		if (!rst_n)
			model_selA <= 2'd0;
		else if(flag)
			model_selA <= 2'd0;
		else if (CH_model_selA_pos)
			model_selA <= model_selA + 1'd1;
		else 
			model_selA <= model_selA;
	end
	
	// 通道B  波形选择
	always@(posedge clk_125M or negedge rst_n) begin
		if (!rst_n)
			`ifdef sim		
				model_selB <= 2'd0; // 仿真时使用
			`else	
				model_selB <= 2'd0; // 板级验证使用
			`endif
			else if(flag)
			model_selB <= 2'd0;
			else if (CH_model_selB_pos)
			model_selB <= model_selB + 1'd1;
		else 
			model_selB <= model_selB;
	end
	
	// 通道A 频率控制字选择
	always@(posedge clk_125M or negedge rst_n) begin
		if (!rst_n)
			`ifdef sim		
				CH_FwordA_sel <= 3'd4; // 仿真时使用
			`else	
				CH_FwordA_sel <= 3'd5; // 板级验证使用
			`endif
		else if (CH_FwordA_pos)
			CH_FwordA_sel <= CH_FwordA_sel + 1'd1;
		else 
			CH_FwordA_sel <= CH_FwordA_sel;
	end
	
	always@(*) begin
		case(CH_FwordA_sel)   
            3'd0:FwordA = 32'd34;//2**32 / 125000000;     34.35  
            3'd1:FwordA = 32'd344;//2**32 / 12500000;
            3'd2:FwordA = 32'd3436;//2**32 / 1250000;
            3'd3:FwordA = 32'd34360;//2**32 / 125000;
            3'd4:FwordA = 32'd343597;//2**32 / 12500;
            3'd5:FwordA = 32'd3435974;//2**32 / 1250;
            3'd6:FwordA = 32'd34359738;//2**32 / 125;
            3'd7:FwordA = 32'd343597384;//2**32 / 12.5;
        endcase
	end

	// 通道B 频率控制字选择
	always@(posedge clk_125M or negedge rst_n) begin
		if (!rst_n)
			`ifdef sim		
				CH_FwordB_sel <= 3'd4; // 仿真时使用
			`else	
				CH_FwordB_sel <= 3'd5; // 板级验证使用
			`endif
		else if (CH_FwordB_pos)
			CH_FwordB_sel <= CH_FwordB_sel + 1'd1;
		else 
			CH_FwordB_sel <= CH_FwordB_sel;
	end
	
	always @ (*) begin
		case(CH_FwordB_sel)   
            3'd0:FwordB = 32'd34;//2**32 / 125000000;     34.35
            3'd1:FwordB = 32'd344;//2**32 / 12500000;
            3'd2:FwordB = 32'd3436;//2**32 / 1250000;
            3'd3:FwordB = 32'd34360;//2**32 / 125000;
            3'd4:FwordB = 32'd343597;//2**32 / 12500;
            3'd5:FwordB = 32'd3435974;//2**32 / 1250;
            3'd6:FwordB = 32'd34359738;//2**32 / 125;
            3'd7:FwordB = 32'd343597384;//2**32 / 12.5;
        endcase  
	end

	// 通道A 相位控制字选择
	always@(posedge clk_125M or negedge rst_n) begin
		if (!rst_n)
			`ifdef sim		
				CH_PwordA_sel <= 3'd0; // 仿真时使用
			`else	
				CH_PwordA_sel <= 3'd0; // 板级验证使用
			`endif
		else if (CH_PwordA_pos)
			CH_PwordA_sel <= CH_PwordA_sel + 1'd1;
		else 
			CH_PwordA_sel <= CH_PwordA_sel;
	end
	
	always @(*) begin
		case(CH_PwordA_sel)
            3'd0:PwordA = 12'd0;   //0
            3'd1:PwordA = 12'd341; //30
            3'd2:PwordA = 12'd683; //60
            3'd3:PwordA = 12'd1024; //90
            3'd4:PwordA = 12'd1707; //150
            3'd5:PwordA = 12'd2048; //180
            3'd6:PwordA = 12'd3072; //270
            3'd7:PwordA = 12'd3641; //320
		endcase
	end

	// 通道B 相位控制字选择
	always@(posedge clk_125M or negedge rst_n) begin
		if (!rst_n)
			CH_PwordB_sel <= 3'd0; // 板级验证使用
		else if (CH_PwordB_pos)
			CH_PwordB_sel <= CH_PwordB_sel + 1'd1;
		else 
			CH_PwordB_sel <= CH_PwordB_sel;
	end

	always @(*) begin
		case(CH_PwordB_sel)
            3'd0:PwordB = 12'd0;   //0
            3'd1:PwordB = 12'd341; //30
            3'd2:PwordB = 12'd683; //60
            3'd3:PwordB = 12'd1024; //90
            3'd4:PwordB = 12'd1707; //150
            3'd5:PwordB = 12'd2048; //180
            3'd6:PwordB = 12'd3072; //270
            3'd7:PwordB = 12'd3641; //320
      endcase
	end
	
endmodule 

//`timescale 1ns / 1ps
//
//`define sim
//
//module DDS_AD9767(
//    Clk,
//    Reset_n,
//    DataA,
//    ClkA,
//    WRTA,
//    DataB,
//    WRTB,
//    ClkB
//);
//    input Clk;
//    input Reset_n;
//    output [13:0]DataA;
//    output ClkA;
//    output WRTA;
//    output [13:0]DataB;
//    output ClkB;
//    output WRTB;
//    
//    wire CLK125M;
//    assign ClkA = CLK125M;
//    assign ClkB = CLK125M;
//    assign WRTA = ClkA;
//    assign WRTB = ClkB;  
//    
//    reg [31:0]FwordA,FwordB;
//    reg [11:0]PwordA,PwordB;
//    reg [1:0]Mode_SelA;
//    reg [1:0]Mode_SelB;
//    reg [2:0]CHA_Fword_Sel;
//    reg [2:0]CHB_Fword_Sel;
//    
//    reg [2:0]CHA_Pword_Sel;
//    reg [2:0]CHB_Pword_Sel;
//   
//   
////    MMCM MMCM(
////        .clk_out1(CLK125M),
////        .resetn(Reset_n), 
////        .locked(),
////        .clk_in1(Clk)
////    );
//
//	PLL_125	PLL_125_inst (
//		.inclk0 ( Clk ),
//		.c0 	  ( CLK125M )
//	);
//////   
////    DDS_Module DDS_ModuleA(
////        .Clk(CLK125M),
////        .Reset_n(Reset_n),
////        .Mode_Sel(Mode_SelA),
////        .Fword(FwordA),
////        .Pword(PwordA),
////        .Data(DataA)
////    );
////    
////    DDS_Module DDS_ModuleB(
////        .Clk(CLK125M),
////        .Reset_n(Reset_n),
////        .Mode_Sel(Mode_SelB),
////        .Fword(FwordB),
////        .Pword(PwordB),
////        .Data(DataB)
////    ); 
//
//	DDS_model DDS_modelA(			// 通道A输出
//		.clk			(CLK125M	), 
//		.rst_n		(Reset_n		),
//		.model_sel	(Mode_SelA	),
//		.Fword		(FwordA		),
//		.Pword		(PwordA		),
//		.data			(DataA		)
//	);
//
//	DDS_model DDS_modelB(			// 通道B输出
//		.clk			(CLK125M	), 
//		.rst_n		(Reset_n		),
//		.model_sel	(Mode_SelB	),
//		.Fword		(FwordB		),
//		.Pword		(PwordB		),
//		.data			(DataB		)
//	);
//    
//    wire CHA_Fword_flag;
//    wire CHB_Fword_flag;
//    wire CHA_Pword_flag;
//    wire CHB_Pword_flag;
//    wire Mode_SelA_flag;
//    wire Mode_SelB_flag;
//    
////    vio_0 vio (
////        .clk(CLK125M),                // input wire clk
////        .probe_out0(CHA_Fword_flag),  // output wire [0 : 0] probe_out0
////        .probe_out1(CHB_Fword_flag),  // output wire [0 : 0] probe_out1
////        .probe_out2(CHA_Pword_flag),  // output wire [0 : 0] probe_out2
////        .probe_out3(CHB_Pword_flag),  // output wire [0 : 0] probe_out3
////        .probe_out4(Mode_SelA_flag),  // output wire [0 : 0] probe_out4
////        .probe_out5(Mode_SelB_flag)  // output wire [0 : 0] probe_out5
////    );
//
//
//	// 通道A 模式选择 虚拟按键输入
//	ISSP	ISSP_model_selA (	
//		.probe (  ),
//		.source ( Mode_SelA_flag )
//	);
//	// 通道A 频率控制字 选择虚拟按键输入
//	ISSP	ISSP_FwordA (	
//		.probe (  ),
//		.source ( CHA_Fword_flag )
//	);
//	// 通道A 相位控制字 虚拟按键输入
//	ISSP	ISSP_PwordA (	
//		.probe (  ),
//		.source ( CHA_Pword_flag )
//	);
//	
//	// 通道B 模式选择 虚拟按键输入
//	ISSP	ISSP_model_selB (	
//		.probe (  ),
//		.source ( Mode_SelB_flag )
//	);
//	// 通道B 频率控制字 选择虚拟按键输入
//	ISSP	ISSP_FwordB (	
//		.probe (  ),
//		.source ( CHB_Fword_flag )
//	);
//	// 通道B 相位控制字 虚拟按键输入
//	ISSP	ISSP_PwordB (	
//		.probe (  ),
//		.source ( CHB_Pword_flag )
//	);
//    
//    //对flag信号打两拍，用于上升沿检测
//    reg CHA_Fword_flag_reg0,CHA_Fword_flag_reg1;
//    reg CHB_Fword_flag_reg0,CHB_Fword_flag_reg1;
//    reg CHA_Pword_flag_reg0,CHA_Pword_flag_reg1;
//    reg CHB_Pword_flag_reg0,CHB_Pword_flag_reg1;
//    reg Mode_SelA_flag_reg0,Mode_SelA_flag_reg1;
//    reg Mode_SelB_flag_reg0,Mode_SelB_flag_reg1;
//    
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)begin
//        CHA_Fword_flag_reg0 <= 0;
//        CHA_Fword_flag_reg1 <= 0;
//    end
//    else begin
//        CHA_Fword_flag_reg0 <= CHA_Fword_flag;
//        CHA_Fword_flag_reg1 <= CHA_Fword_flag_reg0;
//    end
//    
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)begin
//        CHB_Fword_flag_reg0 <= 0;
//        CHB_Fword_flag_reg1 <= 0;
//    end
//    else begin
//        CHB_Fword_flag_reg0 <= CHB_Fword_flag;
//        CHB_Fword_flag_reg1 <= CHB_Fword_flag_reg0;
//    end
//    
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)begin
//        CHA_Pword_flag_reg0 <= 0;
//        CHA_Pword_flag_reg1 <= 0;
//    end
//    else begin
//        CHA_Pword_flag_reg0 <= CHA_Pword_flag;
//        CHA_Pword_flag_reg1 <= CHA_Pword_flag_reg0;
//    end   
//    
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)begin
//        CHB_Pword_flag_reg0 <= 0;
//        CHB_Pword_flag_reg1 <= 0;
//    end
//    else begin
//        CHB_Pword_flag_reg0 <= CHB_Pword_flag;
//        CHB_Pword_flag_reg1 <= CHB_Pword_flag_reg0;
//    end      
//
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)begin
//        Mode_SelA_flag_reg0 <= 0;
//        Mode_SelA_flag_reg1 <= 0;
//    end
//    else begin    
//        Mode_SelA_flag_reg0 <= Mode_SelA_flag;
//        Mode_SelA_flag_reg1 <= Mode_SelA_flag_reg0;
//    end       
//    
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)begin
//        Mode_SelB_flag_reg0 <= 0;
//        Mode_SelB_flag_reg1 <= 0;
//    end
//    else begin
//        Mode_SelB_flag_reg0 <= Mode_SelB_flag;
//        Mode_SelB_flag_reg1 <= Mode_SelB_flag_reg0;
//    end 
// 
//    wire CHA_Fword_posedge;
//    wire CHB_Fword_posedge;
//    wire CHA_Pword_posedge;
//    wire CHB_Pword_posedge;
//    wire Mode_SelA_posedge;
//    wire Mode_SelB_posedge;
//    //上升沿检测   
//    assign CHA_Fword_posedge = (!CHA_Fword_flag_reg1) & CHA_Fword_flag_reg0;
//    assign CHB_Fword_posedge = (!CHB_Fword_flag_reg1) & CHB_Fword_flag_reg0;
//    assign CHA_Pword_posedge = (!CHA_Pword_flag_reg1) & CHA_Pword_flag_reg0;
//    assign CHB_Pword_posedge = (!CHB_Pword_flag_reg1) & CHB_Pword_flag_reg0;
//    assign Mode_SelA_posedge = (!Mode_SelA_flag_reg1) & Mode_SelA_flag_reg0;
//    assign Mode_SelB_posedge = (!Mode_SelB_flag_reg1) & Mode_SelB_flag_reg0;
//    
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)
//        `ifdef sim
//            CHA_Fword_Sel <= 4;//仿真时启用
//        `else
//            CHA_Fword_Sel <= 0; //板级验证时启用
//        `endif
//    else if(CHA_Fword_posedge)
//        CHA_Fword_Sel <= CHA_Fword_Sel + 1'd1;
//    else
//        CHA_Fword_Sel <= CHA_Fword_Sel;
//        
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)
//        `ifdef sim
//            CHB_Fword_Sel <= 4;//仿真时启用
//        `else
//            CHB_Fword_Sel <= 0;  //板级验证时启用 
//         `endif
//    else if(CHB_Fword_posedge)
//        CHB_Fword_Sel <= CHB_Fword_Sel + 1'd1;
//    else
//        CHB_Fword_Sel <= CHB_Fword_Sel;
//
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)
//        `ifdef sim
//            CHA_Pword_Sel <= 3;//仿真时使用
//        `else
//            CHA_Pword_Sel <= 0;//板级验证时使用
//        `endif      
//    else if(CHA_Pword_posedge)
//        CHA_Pword_Sel <= CHA_Pword_Sel + 1'd1;
//    else
//        CHA_Pword_Sel <= CHA_Pword_Sel;
//        
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)
//        CHB_Pword_Sel <= 0;//板级验证时使用
//    else if(CHB_Pword_posedge)
//        CHB_Pword_Sel <= CHB_Pword_Sel + 1'd1;
//    else
//        CHB_Pword_Sel <= CHB_Pword_Sel;
//        
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)
//        Mode_SelA <= 0;
//    else if(Mode_SelA_posedge)
//        Mode_SelA <= Mode_SelA + 1'd1;
//    else
//        Mode_SelA <= Mode_SelA;
//        
//    always@(posedge CLK125M or negedge Reset_n)    
//    if(!Reset_n)
//        `ifdef sim
//            Mode_SelB <= 1;
//        `else
//            Mode_SelB <= 0;
//        `endif
//    else if(Mode_SelB_posedge)
//        Mode_SelB <= Mode_SelB + 1'd1;
//    else
//        Mode_SelB <= Mode_SelB;
//
////频率控制字
////如果把周期完整的一个波形等分成2的32次方份，在时钟频率为125M次/秒的条件下,
////如果希望1秒钟输出一个完成的周期，那么每一拍递进多少份？
//    always@(*)
//        case(CHA_Fword_Sel)   
//            0:FwordA = 34;//2**32 / 125000000;     34.35  
//            1:FwordA = 344;//2**32 / 12500000;
//            2:FwordA = 3436;//2**32 / 1250000;
//            3:FwordA = 34360;//2**32 / 125000;
//            4:FwordA = 343597;//2**32 / 12500;
//            5:FwordA = 3435974;//2**32 / 1250;
//            6:FwordA = 34359738;//2**32 / 125;
//            7:FwordA = 343597384;//2**32 / 12.5;
//        endcase
//        
//    always@(*)
//        case(CHB_Fword_Sel)   
//            0:FwordB = 34;//2**32 / 125000000;     34.35
//            1:FwordB = 344;//2**32 / 12500000;
//            2:FwordB = 3436;//2**32 / 1250000;
//            3:FwordB = 34360;//2**32 / 125000;
//            4:FwordB = 343597;//2**32 / 12500;
//            5:FwordB = 3435974;//2**32 / 1250;
//            6:FwordB = 34359738;//2**32 / 125;
//            7:FwordB = 343597384;//2**32 / 12.5;
//        endcase  
//        
//    always@(*)
//        case(CHA_Pword_Sel)
//            0:PwordA = 0;   //0
//            1:PwordA = 341; //30
//            2:PwordA = 683; //60
//            3:PwordA = 1024;    //90
//            4:PwordA = 1707;    //150
//            5:PwordA = 2048;    //180
//            6:PwordA = 3072;    //270
//            7:PwordA = 3641;    //320
//        endcase 
//
//    always@(*)
//        case(CHB_Pword_Sel)
//            0:PwordB = 0;   //0
//            1:PwordB = 341; //30
//            2:PwordB = 683; //60
//            3:PwordB = 1024;    //90
//            4:PwordB = 1707;    //150
//            5:PwordB = 2048;    //180
//            6:PwordB = 3072;    //270
//            7:PwordB = 3641;    //320
//        endcase
//endmodule
